Method for automatic partitioning of node-weighted, edge-constrained graphs

ABSTRACT

According to an embodiment of the present invention, a method is provided for partitioning a network, comprising modeling the network as a graph comprising nodes which represent network devices, and edges which represent links between the devices, and automatically partitioning the graph into domains. One embodiment of the method includes identifying a number of anchor nodes in the graph and partitioning the domains around the anchor nodes such that each domain contains only one anchor node. Another embodiment of the method includes partitioning a graph without anchor nodes into a number of domains, and assigning controllers to each of the domains. Preferably, the method further includes assigning a weight to each node in the graph, and balancing the partitions as a function of the weight of each node in a respective partition.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates generally to automatic partitioning of graphs andmore particularly to automatic partitioning of communication networksand other physical systems.

2. Discussion of the Related Art

Many physical systems can be modeled by a graph. These includecommunication networks, distributed computing systems, productionsystems and printed circuit board layouts.

Graph partitioning belongs to a class of problems called NP-completeproblems (Garey, M. R. and D. S. Johnson, Computers and Intractability:A Guide to the Theory of NP Completeness, W.H. Freeman & Co., 1979). AnNP-complete problem is a problem which can only be solved by thecomplete enumeration of all the feasible solutions (i.e., those thatsatisfy all the constraints imposed on the problem) from which the bestsolution will be chosen. This is a very inefficient method of solvinglarge problems. Unfortunately, there is no known efficient method ofsolving this class of problems, and this has often necessitated the useof heuristic methods. Heuristic methods are intended to produce good,but not necessarily optimal, solutions.

One of the earliest methods of solving the problem is the spectralpartitioning method (Pothen, A. et al., “Partitioning Sparse Matriceswith Eigenvectors of Graphs,” SIAM J. of Matrix Analysis. andApplications, 11(3):430-452 (1990); Hendrickson, B. and R. Leland, “AMultilevel Algorithm for Partitioning Graphs,” Technical Report,SAND93-1301, Sandia National Labs (1993)). However, this method is veryexpensive since it requires the computation of the eigenvectorcorresponding to the second smallest eigenvalue. Thus, the method islimited in practice to graphs of very small sizes.

Another method of solving the problem is the geometric partitioningmethod (Miller, G. et al., “A Unified Geometric Approach to GraphSeparators,” Proc of 31st Annual Symposium on Foundation of ComputerSci., 538-547 (1991); Heath, M. and P. Raghavan, “A Cartesian NestedDissection Algorithm,” Tech. Report UIUCDCS-R-92-1772, Dept. of ComputerSci., Univ. of Ill., Urbana, Ill. (1992); Nour-Omid, B. et al., “SolvingFinite Element Equations on Concurrent Computers,” Am. Soc. of Mech.Engineers, 291-307, (A. K. Noor, ed. 1986)). However, this methodprovides partitions that are worse than those of the spectral method. Amajor limitation of this method is that it requires knowledge of thecoordinates of the vertices of the graph. Unfortunately, in many areas,such as communication networks and VLSI design, there is no geometry or“coordinates” associated with the graph.

A multilevel partitioning method has also been proposed (Bui, T. and C.Jones, “A Heuristic for Reducing Fill in Sparse Matrix Factorization,”Proc. of 6th SIAM Conf. on Parallel Processing for Scientific Computing,445-452 (1993); Cheng, C. and Y. Wei, “An Improved Two-way PartitioningAlgorithm with Stable Performance,” IEEE Trans on Computer-Aided Design,10(12):1502-1511 (1991); Hagen, L. and A. Kahng, “Fast Spectral Methodfor Ratio Cut Partitioning and Clustering,” Proc of IEEE InternationalConf on Computer-Aided Design, 10-13 (1991); Hagen, E. and A. Kahng, “ANew Approach to Effective Circuit Clustering,” Proc of IEEEInternational Conf on Computer-Aided Design, 422-427 (1992); Garbers, J.et al., “Finding Clusters in VLSI Circuits,” Proc. of IEEE InternationalConfon Computer-Aided Design, 520-523 (1990); Karypis, G. and V. Kumar,“A Fast and High Quality Multilevel Scheme for Partitioning IrregularGraphs,” Technical Report 95-035, Dept. of Computer Sci., Univ of Minn.,Minnesota, Minn. (1995)). This method coarsens the graph (i.e., reducesthe size of the graph) by collapsing the nodes and edges; it partitionsthe smaller graph, and then uncoarsens it to construct a partition ofthe original graph. Unfortunately this method is very complicated andhas not yet been shown to be better than the other two methods.

In all the above methods, it is assumed that the graph is not weighted.This means that all the nodes are essentially identical and the onlyobjective is to partition the graph to generate an equal number of nodesin each partition. When weights are associated with either the nodes orthe edges, none of these methods will work adequately. Moreover, thecost of solving the problem will be very high. None of these methods hasbeen proposed for use in a communication network.

SUMMARY OF THE INVENTION

The present invention is a method for automatically partitioningnode-weighted, edge-constrained graphs. In contrast with the prior art,the present invention automatically manipulates the nodes of a graph topartition the graph without the need for manually configuring each node.The present invention uses a software control mechanism to partition thegraph and, if necessary, to re-partition the graph, without the need tomanually intervene in the configuration of the network.

According to one embodiment of the present invention, a method isprovided for partitioning a network comprising modeling the network as agraph comprising nodes which represent network devices, and edges whichrepresent links between the devices, and automatically partitioning thegraph into domains. Preferably, the method further includes a step ofassigning a weight to each node in the graph, and the partitioning stepincludes balancing partitions as a function of the weight of each nodein a respective partition.

In another embodiment of the invention, a method is provided fordeveloping a partitioning scheme for a communication network having aplurality of interconnected devices. The method includes automaticallydetermining a topology of the communication network, automaticallypartitioning the communication network into a number of domains, eachincluding a number of the plurality of devices, and informing each ofthe number of devices in each of the domains of partitioninginformation.

In another embodiment of the invention, a method is provided forautomatically partitioning a graph into domains, the graph having aplurality of nodes interconnected by a plurality of edges. The methodincludes identifying a number of anchor nodes in the graph, combiningthe nodes into a number of control groups which number is the same asthe number of domains, such that each control group includes only oneanchor node.

In yet another embodiment of the invention, a method is provided foroperating a partitioned communication network having a plurality ofnetwork devices interconnected by a plurality of communication links.The method comprises detecting a failure of a network device,automatically generating a new partition based on a topology of thenetwork without the failed device and operating the communicationnetwork using the automatically-generated partition. The automaticgenerating step includes determining the topology of the network withoutthe failed device. The topology is a graph representation of thecommunication network having nodes representing the network devices andedges representing the communication links. The method further includesidentifying supernodes in the graph representation, forming a pluralityof clusters of nodes based on the identified supernodes and generatingnew domains based on the clusters.

Such an automated system has the advantage that it can have a built-inmechanism that allows the network control agents to monitor oneanother's status. They cooperatively take over the control of a domainwhose control agent has failed. Similarly, when the failed device comesup again, the other agents relinquish control of its domain.

Another advantage of an automated system is load balancing. A manuallyconfigured system is generally static and does not respond easily to theload changes in the system. An automated system partitions the systeminto as many domains as there are available control agents and ensuresthat each agent has a fair share of the load (or traffic). Typically,there is in the background a continuous monitoring of the loaddistribution among the different agents and the domain boundaries areperiodically adjusted to reflect the changes in the system.

In yet another embodiment of the invention, a domain partitioning engineis provided which includes means for receiving a representation of agraph comprising nodes and edges, means for identifying supernodes andmeans, responsive to the means for identifying, for automaticallypartitioning the graph into a number of domains. Preferably, the enginefurther comprises means for assigning a weight to each node in thegraph, and the means for partitioning includes means for balancing thepartitions as a function of the weights of each node in a respectivepartition.

In yet another embodiment of the invention, a method for automaticallypartitioning graphs is provided, wherein a number of anchor nodes areidentified, supernodes are formed from nodes in the graph and clustersare formed from the supernodes around each of the anchor nodes, suchthat each cluster includes only one anchor node. The weights of theclusters are balanced and domains are generated from the clusters.

These and other features and advantages shall appear from the followingdetailed description of the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A illustrates an example of a weighted graph;

FIG. 1B illustrates one method of partitioning a communication network,according to the present invention;

FIG. 2 illustrates a supernode consisting of three mutual adjacent nodesin accordance with one embodiment of the present invention;

FIG. 3A is a flow diagram of a method performed in order to partitiongraphs having identified anchor nodes in accordance with the presentinvention;

FIG. 3B is a flow diagram of an alternate method performed in accordancewith the present invention;

FIG. 4 is an adjacency matrix in accordance with the present invention;

FIGS. 5A-5C illustrate an example of partitioning a graph with anchornodes in accordance with the present invention;

FIGS. 6A-6C illustrate an example of partitioning a graph with anchornodes in accordance with the present invention;

FIGS. 7A-7C illustrate an example of partitioning a graph with anchornodes in accordance with the present invention;

FIGS. 8A-8D illustrate an example of partitioning a graph with anchornodes and uncovered nodes (as defined below);

FIGS. 9A-9B illustrate an example of partitioning of a graph with anchornodes in accordance with the present invention;

FIGS. 10A-10B illustrate an example of partitioning a graph havinganchor nodes as backbone nodes;

FIGS. 11A-11B illustrate an example of partitioning a star-configuredgraph having anchor nodes as leaf nodes;

FIGS. 12A-12B illustrate an example of partitioning a doublestar-configured graph having anchor nodes as backbone nodes;

FIG. 13 illustrates an example of partitioning a triple star-configuredgraph having anchor nodes as backbone nodes;

FIGS. 14A-14B illustrate an example of partitioning a doublestar-configured graph having anchor nodes as backbone nodes andnon-backbone nodes;

FIGS. 15A-15B illustrate an example of partitioning a triplestar-configured graph having anchor nodes as backbone nodes andnon-backbone nodes;

FIGS. 16A-16B illustrate an example of partitioning a graph having botha backbone structure and a mesh structure;

FIG. 17 is a flow diagram of a process performed in order toautomatically partition graphs in accordance with a second embodiment ofthe present invention;

FIG. 18 illustrates a graph which is partitioned into two domains;

FIGS. 19A-19C illustrate an example for generating domains in accordancewith the second embodiment of the present invention;

FIG. 19D is a flow diagram of the process performed in the example ofFIGS. 18A-18C;

FIGS. 20A-20F illustrate cluster generation from uncovered nodes;

FIG. 20G is a flow diagram of the process performed in the example ofFIGS. 19A-19F;

FIGS. 21A-21D illustrate another example of cluster generation fromuncovered nodes;

FIG. 21E is a flow diagram of the process performed in the example ofFIGS. 20A-20D;

FIGS. 22A-22D illustrate an example of cluster partitioning;

FIG. 22E is a flow diagram of the process performed in the example ofFIGS. 21A-21D;

FIGS. 23A-23D illustrate an example of cluster combination;

FIG. 23E is a flow chart of a process performed in the example of FIGS.22A-22D; and

FIG. 24 illustrates a computer system which may be implemented to carryout the method of the present invention.

DETAILED DESCRIPTION

Communication networks can be modeled as a graph. In the case of acommunication network, the nodes of the graph represent the networkdevices (e.g., hubs, switches, routers, bridges) and the edges of thegraph represent the links or communication channels interconnecting thenetwork devices.

The control of a large communication network may then be achieved bypartitioning the network into smaller units or sub-networks calledcontrol domains (or domains, for short) with each domain being managedby a control agent. Several criteria can be used to effect thepartitioning. Partitioning may be done to minimize the communicationflow across domains. The desired number of partitions may or may not beknown a priori and any node can be in any domain as long as the goal ofminimizing the flow across domains is achieved.

For communication networks, the partitioning process is done manually inthe prior art. The techniques which are typically used in partitioningprior art switched networks is the same as the manual techniques used topartition connectionless networks. This presents a lot of problems. Oneproblem is an assumption that the number of control agents is known apriori. In the event of failure of one agent, however, a section of thesystem is left without a controller (or control agent). It would thus bedesirable to provide a method for automatically partitioning acommunication network to provide efficient distribution and use of nodesfor an initial assignment of partitions, for recovery from failure of acontrol agent, as well as other reasons apparent from this disclosure.

In one embodiment of the present invention, a method for automaticallypartitioning a graph is provided. This embodiment may be used, forexample, to automatically partition nodes in a communication network.While the following discussion is presented in the context ofpartitioning of a communication network, this is not intended aslimiting.

Consider a communication network consisting of N switches interconnectedby communication links in an arbitrary manner. Assume that the switchesare labeled 1, 2, . . . , N, and switch i (i=1, . . . , N) has a valuev_(i). Several criteria can be used to assign a value v_(i) to a switch.For example, v_(i) can be proportional to the number of ports on theswitch; it can denote a measure of the expected total traffic seen bythe switch; or it can denote the number of functions provided by theswitch. Whatever criteria is used to assign value, in the embodimentdescribed below, if v_(i)>v_(j), for all i not equal to j, then switch iis considered more functionally capable than switch j. Finally, thereare anchor nodes to which are attached copies of a network managementagent. The number of anchor nodes is typically considerably less than N.

Several criteria can also be used to classify the links. One suchcriterion is the capacity of the link (or its bandwidth or informationcarrying power). Links may be classified into three types: normal links(which have average capacity), strong links (which have very largecapacity), and weak links (which have smaller than average capacity).Other criteria may reflect a current communication load carried by thelink.

Partitioning of the network may be modeled by a weighted graph in whichthe nodes of the graph denote the switches, the edges of the graphdenote the communication links, and the weight of a node of the graphdenotes the number of ports each node supports. Thus, two nodes of thegraph will be adjacent (i.e., connected by an edge) if the two switchesthey represent are connected by a link, i.e., a communication channelwhich may be a physical link such as a cable (optical, electrical orotherwise), or even a wireless link made over the air waves.

FIG. 1A shows an example of a communication network modeled as a graph.The circles represent the nodes and the lines between circles representthe edges of the graph. The number beside each node denotes its weightwhile identification numbers are placed inside the nodes. Shaded nodes3, 6 and 10 are anchor nodes. Edges (3, 5), (4, 7), and (8, 11) are weaklinks, while all other links are normal links.

In practice, there may be certain restrictions to including a node in aparticular domain. For example, there may be instances where twoadjacent nodes need to be in different domains. One reason for this maybe that the two nodes are interconnected by a low-capacity link thatwould be a bottleneck for intra-domain traffic routing. (Assuming thatintra-domain traffic is usually heavier than inter-domain traffic.)Therefore, it may be preferable that the high-capacity links be used forintra-domain traffic while limiting the low-capacity links tointer-domain traffic. Also, experience may show that the traffic acrossa link between two switches is so small that the nodes can essentiallybe considered unconnected. Because such restrictions affect the locationof nodes among domains, these parameters may be referred to as “edgeconstraints.” A good partitioning algorithm should be robust enough tohandle such restrictions.

Another problem often encountered in real networks is that the controlagents that manage the domains may be physically attached to selectnodes, and thus these select nodes must be located in the domain managedby the attached agent. A node on which a control agent is attached isdefined as an “anchor node.” A good partitioning algorithm should berobust enough to handle networks with anchor nodes and in such cases,the number of domains depends on the desired number of control agents,i.e., the number of anchor nodes. In practical effect the domain to bemanaged by a control agent may need to be centered around its anchornode. However, a graph may be partitioned without knowledge of theexistence or location of anchor nodes. In this case, the control agentsmay be assigned to domains after the graph has been partitioned.

Partitioning a Communication Network

FIG. 1B illustrates a method of partitioning nodes in a communicationnetwork. At a step 201, the network is modeled as a topology, asgenerally described above. As discussed above, switches are representedas nodes in the graph and communication links are represented as edgesof the graph. Edges and/or nodes may be assigned a weight, based oncommunication capacity or some other parameter. The step 201 may includethe step of determining the network topology.

At a step 202, this graph is automatically partitioned. Certainembodiments of processes for automatic partitioning are described ingreater detail below.

In one embodiment, partitioning is performed within a partitioningengine in a Network Management Server (NMS) (the engine being softwarerunning on a general purpose computer used by the NMS). Such an NMS isdescribed in U.S. Pat. No. 5,261,044, which patent is commonly owned byCabletron Systems, Inc., Rochester, N.H., USA, and is incorporatedherein by reference in its entirety.

Thus, at step 201, the NMS would discover the topology of thecommunication network. An automatic discovery tool which is used in theNMS is disclosed in U.S. patent application Ser. No. 08/115,232 filed onSep. 1, 1993, which application is commonly owned with the presentpatent application and is incorporated herein by reference in itsentirety. Once the topology of the network has been discovered, thenetwork is automatically partitioned according to the present invention,at step 202.

In another embodiment, each of the control agents may independentlydiscover the network topology information and independently partitionthe graph. In such a situation, of course, it may be important that eachcontrol agent reach the same conclusions about how the network ispartitioned into domains.

The partitioning process problem may (but need not) include one or moreof the following parameters as desired characteristics of thepartitioned graph/network:

1. The total value of the switches in each of the domains lies within apredefined range. For example, this range may be set to ensure that noone domain is overloaded while some others are lightly loaded. The limitalso provides some elasticity in the system because if one strives togenerate domains with equal values while meeting all the otherconditions that will be defined here, the problem may not have asolution.

2. No two switches interconnected by a weak link are in the same domain.The rationale for this is that it is expected that most of the trafficin the network will be intra-domain traffic. Therefore, intra-domainlinks will be heavily used and thus are required to have a high capacityin order not to be a bottleneck in the system.

3. Any two switches interconnected by a strong link are required to bein the same domain. The reason for this is clear, based on thediscussion in number 2 above.

4. There can be only one anchor node in each domain. Thus, the requirednumber of domains is the number of anchor nodes.

After step 202, at a step 203, the domains (partitions of the graph) areassigned to control agents. This involves informing each control agentwhich switches are within that agent's domain. (In one embodiment,control agents are assumed to be at fixed points within thecommunication network. In another embodiment, assignment of controlagents may take place as a result of the partitioning process.) Eachdomain may be assigned a primary control agent, which controls thedomain during normal operation, and a secondary control agent, whichtakes over control of the domain if the domain's primary control agentmalfunctions. The secondary control agent is typically the control agentwhich is closest (i.e. having the shortest hop count) to the primarycontrol agent. In the event that the control agents are independentlypartitioning the network (each reaching the same conclusion), such astep may be omitted.

At a step 204, operation of the communication network may proceed.Operation of a communication network, given a partitioning of thenetwork, is known in the art.

An arrow 205 indicates that, during operation of the network, automaticpartitioning may resume. This may occur to serve one of two goals.First, partitioning may resume in response to detection of a change inthe configuration of the network. For example, a new partitioning may berequired after a link fails, the network topology is changed or ananchor switch (control agent) fails. Second, as described in greaterdetail below, the partitioning may be changed to achieve a more balancedcommunication load over links in the network. Thus, the partitioningprocess can respond to failed links or the discovery that a certain linkin a configuration cannot handle its current communication load.

Automatic Partitioning

At step 202, the graph-model of the communication network isautomatically partitioned. This may be done in a variety of ways.

Advantages in the automatic partitioning process may be achieved,according to the present invention, by one or more of the steps of: a)defining a good starting point for the partitioning process; and b)preventing the inclusion of any set of nodes or edges in the samedomain.

One of the major difficulties in finding a solution to the graphpartitioning problem is that of finding a good starting point for thepartitions. One embodiment of the present invention overcomes thisproblem by defining the concept of a “supernode.” A “supernode” is a setof nodes that are mutually adjacent to one another and there is no weakedge between any two members of the set (i.e. a fully connected graphwith no weak edges). The simplest supernode is a triangular supernode ortriplet. FIG. 2 shows a triplet consisting of three mutually adjacentnodes 100, 102 and 104 interconnected by links or edges 101, 103 and105.

Another concept used in one embodiment is that of “clusters.” “Cluster”simply refers to a set of nodes. In one embodiment, clusters are simplydifferent sets of nodes that are formed and then adjusted until anacceptable partitioning of the graph is identified.

A node is considered “covered” if it is included in at least onesupernode or one cluster; a node is “uncovered” if it is not included ina supernode or cluster. As described in greater detail below, a clusteris configured such that each node in the cluster is adjacent to at leasttwo other nodes in the cluster. If any supernode shares two or morenodes with another supernode, the supernodes are combined into onecluster. If any supernode shares two or more nodes with a cluster, thesupernode is absorbed into the cluster. If two clusters have a node incommon, one cluster is shunk by removing the shared node from thecluster.

Partitioning Graphs with Anchor Nodes

One embodiment of a method of automatically partitioning a graph maygenerally be described with reference to FIG. 3A, the individual stepsbeing discussed in greater detail below. In this embodiment, thepresence of anchor nodes makes it unnecessary to construct clusters inan arbitrary manner.

These steps will be discussed in greater detail below, but the followingoverview may assist in understanding this embodiment. First, a range ofweights is defined for the domains (step 11). This is usually the totalweight of all nodes of the graph divided by the number of anchor nodes,plus or minus some tolerance. Triangular supernodes are then identifiedin the graph (step 13). After all triangular supernodes have beenidentified, all uncovered nodes are identified (step 15). At this time,an uncovered node is a node that is not included in any triangularsupernode (at this point there are no clusters). All uncovered nodes areincluded in an uncovered node list for future reference when clustersare formed. If the number of uncovered nodes is more than half of thetotal number of nodes (step 16), an alternate method (steps 18-34, FIG.3B) is followed, which is described below. Assuming the number ofuncovered nodes is not more than half, a cluster is formed by startingwith a first supernode that includes an anchor node (step 17). Anysupernode that shares two nodes in common with the first supernode isabsorbed into the first supernode to form a cluster. The cluster size isincreased by merging it with any supernode which has two nodes in commonwith the cluster. This is continued until the cluster size cannot beincreased any further, that is, until no supernode that has not beenincluded in the cluster shares two nodes with the cluster. No supernodethat includes another anchor node can be included in the cluster.Similarly, if the addition of a supernode to the cluster will cause thecluster to include a weak edge, that supernode will not be included inthe cluster. The above step (17) is repeated for each anchor nodewithout regard to whether a supernode has been included in anothercluster or not. If an anchor node remains uncovered, the supernodedefinition is expanded to that of a pair of adjacent nodes connected viaa non-weak link. Neighbor nodes are then selected with no in-betweenweak links, and are added to its cluster. The uncovered anchor node isthen deleted from the uncovered node list.

The weight of each cluster is then found (step 19). If two clusters havea node in common, the node is assigned to a cluster according to anassignment scheme described below (steps 21, 23). Thus, clusters withunique memberships are generated.

The unincluded supernodes and uncovered nodes are then assigned to theclusters in a manner that ensures that no cluster weight lies outsidethe defined range and no weak edges are introduced into a cluster (steps25, 27). If all nodes have been assigned to the clusters (step 29), theweight of each cluster is determined (step 31). If the weight of eachcluster lies within the defined range (step 33), each cluster becomes adomain (step 35), and the problem has been solved. Otherwise boundarynodes are moved to balance the weights (step 37).

Each step described above will now be discussed in greater detail.

Defining Weight Range (Step 11 of FIG. 3A)

To define the weight range, the following method may be used: Let“Tot_Wt” denote the total weight of all the nodes in the graph, and let“n” denote the number of anchor nodes in the graph. Let “Av_Wt”=Tot_Wt/ndenote the average weight of a domain in an optimally partitioned graph.Let “Min_Wt” denote the smallest node weight, and “Max_Wt” denote thelargest node weight. The range may be defined as:

Range=[Low_Range, Hi_Range], where

Low_Range=Av_Wt—Min_Wt

Hi_Range=Av_Wt+Min_Wt

The low end of the range is the theoretical optimum average minus thesmallest weight in the graph, and the high end of the range is thetheoretical average plus the smallest weight. Note that otherdefinitions can be used. That is, tolerances other than the smallestweight can be used. In the event that no partitioning is found thatmeets the tolerances, the method may incrementally increase thetolerance to permit a solution to be found.

Identification of Supernodes (Step 13 of FIG. 3A)

Step 13 of the method specifies identification of the supernodes. Thetriangular supernode is preferably used because it is the simpleststructure with a dimension that is larger than two. Using a pair ofnodes (i.e., dimension is 2) would involve listing every pair ofadjacent nodes. On the other hand, using a structure of a higherdimensionality than three may lead to a more complex method, e.g.,dealing with a graph that does not have such structures. For example, asupernode of dimensionality four is the quad: a four-node graph in whichevery node is adjacent to every other node. If these do not exist, thisaspect of the method would not be helpful. Thus, in a preferredembodiment supernodes of three nodes are used and supernodes having 4 ormore nodes are not.

An adjacency list of node i, A_(i), is the set of nodes that areadjacent to node i. Graph adjacency information may be constructed inthe form of an adjacency matrix such that if node i and node j areadjacent, the entry in row i, column j is 1; otherwise, it is zero.Thus, for example, the adjacency matrix for the graph of FIG. 1A isshown in FIG. 4. In the table, the zero-valued entries (representingnon-adjacent nodes) have been left blank. Nodes which are adjacent toeach other are marked with a “1” in the intersecting columns and rows.For example, node 2 is adjacent to nodes 1, 3 and 4. Adjacent nodes withweak edges interconnecting them have entries labeled “W” to indicatethat, as much as possible, the two nodes should be in different domains.Also, although it is not shown, if two nodes are required to be in thesame cluster, they are “lumped” into one node and not considered asseparate nodes. The weight of the lumped node is the sum of the two nodeweights.

A supernode list is then constructed that contains the supernodes in thegraph. The supernodes are generated as follows:

For each node i, the adjacency list is retrieved. Let A_(i) denote theadjacency list for i, let a_(ij) denote the j^(th) entry in A_(i), andlet i denote the number of entries in A_(i).

The supernodes are found as follows:

For each node i in the graph and for each node j for which a_(ij) is notzero:

If node k is in the adjacency list of node i (i.e., a_(ik) is not zeroor W (weak)) and k is also in the adjacency list of j (i.e., a_(jk) isnot zero or W), then the triplet {i,j,k} is a supernode. Order thetriplet (to make comparison easy) and if the ordered triplet is not inthe supernode list, append it to the list; otherwise drop the triplet.

Continue until all triangular supernodes that include nodesi i and jhave been identified and added to the supernode list.

In step 15, FIG. 3A, the uncovered nodes are identified. That is, thenodes that are not included in any triangular supernode are identifiedas such.

The computational complexity of a method is a measure of the“efficiency” of the method; the more “complex” the method, the lessefficient it is. The computational complexity of a method is determinedby the number of operations the method requires to solve the problem.The operations include additions and multiplications, since all otheroperations are composites of additions and multiplications.

The largest number of operations in the present algorithm is incurred inthe supernode formation. For an N-node, E-edge graph, let the maximumnumber of non-zero entries in the adjacency table (i.e., the largestdegree of the graph) be d. Then the maximum number of comparisonsrequired to generate all the supernodes associated with an arbitrarynode is d(d−1)/2. This is obtained by observing that in the supernodegeneration process, for the first member of the adjacency list, d−1comparisons are done to see if any of the other d−1 nodes is in itsadjacency table. The next member of the list is then compared with theremaining d−2 members since it need not compared again with the first;(the ordering of the nodes in a supernode is not important). This iscontinued until the second to the last member is only compared with thelast member; the number of operations is thus the sum of the first d−1integers. Thus the process of generating all the supernodes requires atmost Nd² comparisons. In conventional notation, the complexity of thesupernode generation process is O(Nd²).

Even for a complete graph (in which every node is adjacent to everyother node), this results in a complexity of O(N³). For graphs withsparse connectivity matrices (i.e., d is very small), the complexity isapproximately linear in N; that is, the complexity is approximatelyO(aN), where a is some scale factor. An algorithm with a computationalcomplexity that is linear in the number of nodes in the graph is a verydesirable algorithm because it scales well with the size of the network.Unfortunately such algorithms are hard to design, and the goal is tofind algorithms that have a complexity that is approximately linear inthe number of nodes, N. Since most networks of practical interest havegraphs with very sparse adjacency matrices, the present algorithm tendsto scale very well with the size of networks of practical interest. Forexample, consider a 4,000-node graph (i.e., N=4,000) and defineb=N*(d²). If d=3, then b=36,000; if d=4, then b=64,000; and if d=7, thenb=196,000. Note that this is a very loose bound. A tighter bound isb=N*d(d−1)/2, which gives b=12,000 for d=3; b=24,000 for d=4; andb=84,000 for d=7.

For most graph partitioning methods, the complexity is a function ofboth the number of nodes and the number of edges. However, as we havedemonstrated above, the complexity of the present method is a functionof the number of nodes and the largest node degree. Thus, the algorithmcan be scaled to large graphs or networks without becoming intractable.

More efficient search routines for identifying supernodes could beimplemented by one of ordinary skill in the art. For example, after thesupernode (i j, l) has been formed, the above method would also searchfor and form the supernodes (i, l, j), (j, i, l,), (j, l, i), (l, i, j)and (l, j, i) that are obtained when the adjacency list of node j andnode l are processed. In practice, however, the six (equivalent)supernodes need be obtained only once and never rediscovered. Thus,supernodes may be identified using computational processes that havesignificantly less computational complexity than that stated above.

Degenerate Cases (Step 16 of FIG. 3A)

If more than half the nodes are uncovered, the graph is treated as a“degenerate” case. In this event, the partitioning process proceeds asdescribed below with reference to FIG. 3B. Of course, the percentage ofuncovered nodes which triggers a degenerate case could be different than50%.

Cluster Generation from Supernodes (Step 17 of FIG. 3A)

In this phase of the procedure, the supernodes have already beenidentified and included in the supernode list, and the uncovered nodeshave also been identified and included in an uncovered node list. Theclusters are formed around known anchor nodes in the following manner.

For each anchor node that is “covered,” one of the supernodes that theanchor node is a member of is chosen as the initial cluster for theanchor node. The selected supernode must not include another anchornode. Where more than one supernode can be selected, a supernode isselected that has the fewest nodes adjacent to another anchor node.

After the initial supernode is selected, for any other supernode thatincludes the anchor node, if the other supernode has two nodes in commonwith the initial cluster and none of its nodes is adjacent to a node inthe cluster via a weak link, the other supernode is included in thecluster and the cluster node membership is updated. This step iscontinued until a cluster for each covered anchor node has been formed.

For an anchor node that is not covered, all adjacent nodes to the anchornode are found and used to form the initial cluster for the anchor node,with the anchor node included in the cluster. If these nodes are in theuncovered node list, they are deleted from the list. The clustermembership is then updated by the following rule. If any of the nodes inthe initial cluster is in a supernode, the supernode is included in thecluster and the rule for the covered anchor node is then followed. Thatis, all supernodes that have two nodes in common with the cluster arefound, added to the cluster and the cluster membership is updated,provided that weak links are excluded within the cluster. If none of thenodes in the initial cluster is a member of a supernode, any supernodehaving two nodes adjacent to the nodes in the initial cluster is foundand the supernode is added to the cluster. Thereafter, the rule for acovered anchor node is followed. All the unincluded supernodes are thenidentified and an unincluded supernode list is formed.

Domain Generation (Steps 19-37 of FIG. 3A)

This part of the method assumes that the clusters have been formed inthe manner described above. In forming the clusters, no attempt is madeto prevent any supernode, and hence any node, from being in more thanone cluster. A domain may be derived from a cluster through thefollowing actions:

1. Ensuring that every uncovered node has been included in a cluster.

2. Ensuring that every node in an included supernode is in exactly onecluster.

3. Ensuring that when the cluster memberships are eventually unique, theweights of the clusters lie within the predefined range.

The domain generation phase may work in the following manner. The weightof each cluster is determined by adding the weights of each node in thecluster (i.e., at step 19). If a node is in more than one cluster (step21), it is assigned to a cluster according to the following scheme (step23): Initially, the node is attempted to be assigned to the cluster withthe lower weight. However, if the common node is in a supernode with ananchor node, it is assigned to the cluster in which the anchor node islocated. If neither of the above options is possible, if the common nodeis in every supernode of a cluster with the cluster's anchor node, thenode is assigned to that cluster. An example of this case is shown inExample 6 below. Cluster weights then are updated (step 19).

Once this is complete, if the unincluded supernode list is not empty,those supernodes, all of whose members have been included in theclusters through other supernodes, are identified and such supernodesare deleted from the unincluded supernode list. If the unincludedsupernode list is still not empty, then for each supernode in the list,it is determined if there is a supernode (in a given cluster), whereintwo of the nodes of the given supernode are adjacent to two nodes in theunincluded supernode, and wherein no node in the given supernode isconnected to a node in the cluster via a weak link. If this condition issatisfied, the unincluded supernode is assigned to the cluster anddeleted from the unincluded supernode list. This condition ensures thatevery node in a cluster is reachable from other nodes in the cluster viaat least two paths having no node in common, which can be an importantreliability issue in communication networks.

If, after the above steps, the unincluded supernode list is still notempty, then the nodes in the unincluded supernode list (that are not inany cluster) are identified and included in the uncovered node list.

If the uncovered node list is not empty, then for each node in the list,the clusters that contain nodes that are adjacent to the node vianon-weak edges are found and the uncovered node is included in thecluster with the smallest weight (step 27). The cluster weight isupdated and the node is deleted from the uncovered node list. If all thenodes are now included in the clusters (step 29), a partitioning processthat makes cluster membership unique is commenced. If, in step 29, it isdetermined that there are still unassigned nodes, steps 25-29 arerepeated.

The weights of the clusters again are determined (step 31). If theweight of every cluster lies within the range defined in step 11 (step33), the clusters become the domains (step 37). If the weight of anycluster is outside the range (step 33), the cluster with the largestweight having at least one node adjacent to a node in the cluster withweight outside the range, is found. A node that is adjacent to anothernode in the smaller-weight cluster is deleted from the larger-weightcluster and the deleted node is included in the cluster with the smallerweight (step 35) (the weights being defined as described above). Ofcourse, modifications and improvements in the movement of nodes betweenclusters are possible. Cluster memberships and cluster weights are thenupdated. The above process is repeated until all clusters have weightsthat lie within the range. The clusters then become the desired domains(step 37).

The method attempts to both balance the weights of the clusters andensure that each node is adjacent to at least two other nodes in thecluster. However, adjacency of nodes within each cluster is preferredover balancing the weight of each cluster. There may be a case where, inorder for the weight of the cluster to be balanced, a leaf node may beincluded in a cluster in which the leaf node is adjacent to only oneother node in the cluster. (“Leaf node” refers to a node that isadjacent to only one node in a cluster.) In this case, since a choicemust be made between balancing the weight of the cluster and causing aleaf node to be formed, or not balancing the weight of the cluster andensuring that each node is adjacent to at least two other nodes, thelatter configuration may be preferred. The weight of the cluster may notbe brought to within the desired range, but all of the nodes of thecluster will be adjacent to at least two other nodes in the cluster.

EXAMPLES OF PARTITIONING GRAPHS WITH ANCHOR NODES

The following examples demonstrate how graph partitioning with assignedanchor nodes is implemented.

Example 1

This example illustrates how the invention partitions the graph of FIG.1A. FIG. 5A shows the graph of FIG. 1 including anchor nodes 3, 6 and10. First, the weight range of the domains is determined (step 11 ofFIG. 3A). The total weight of the graph is 192, and the theoreticalaverage weight is 64 (i.e., 192/3). Since the minimum weight in thegraph is 8, the range is (64−8, 64+8)=[56, 72]. The supernodes then areidentified (step 13). These are denoted by dashed lines and labeled A,B, . . . , F in FIG. 5B. That is, the supernode list is {A, B, C, D, E,F}. Next, the uncovered nodes are identified and the uncovered node listis formed (step 15). This list is {5, 6}. Here, an anchor node (node 6)is an uncovered node. Since not more than half of the nodes areuncovered (step 16), the cluster formation phase is then commenced (step17). Starting with anchor node 3, supernode A (containing nodes 1, 2 and3) is chosen as the starting supernode and a member of a cluster.Supernode B has two nodes in common with the cluster: nodes 2 and 3.Supernode B becomes part of the cluster since it has two nodes in commonand its inclusion does not bring into the cluster any nodes that areadjacent via a weak edge. Supernodes A and B are now placed in theincluded supernode list. Since no other supernode shares two nodes withthe cluster, the cluster is the set of nodes {1, 2, 3, 4}. Next weconsider the second anchor node, anchor node 6, which is an uncoverednode. An initial cluster is formed that includes node 6 and itsneighbors: nodes 5 and 9, but not node 3 since it is an anchor node.Thus the initial cluster is the set of nodes {5, 6, 9}. Now, node 9 isin supernode D; thus, the supernode D (containing nodes 8, 9 and 12) isincluded in the cluster, it is placed in the included supernode list,and the cluster membership is updated to be the set of nodes {5, 6, 8,9, 12}. No other supernode has two nodes in common with the cluster, soconsideration of anchor node 6 is complete. Next anchor node 10 isconsidered, which is in three supernodes, C, E and F. Supernode C isarbitrarily chosen as the initial cluster and it is placed in theincluded supernode list. It shares two nodes with supernode F, so thelatter is included in the cluster which consists of the set of nodes {7,10, 11, 14}. The only supernode left in the supernode list is supernodeE. However, is has two nodes in common with the cluster: nodes 10 and14. Thus, it is included in the cluster and deleted from the supernodelist that is now empty. The cluster is the set {7, 10, 11, 13, 14}.Supernodes E and F are also included in the included supernode list.Clusters 1-3 are shown in FIG. 5C.

The domain generation phase is then commenced. First, it is observedthat all the nodes have been included in at least one cluster (nouncovered nodes). As was determined in step 11, the weight range of eachdomain is [56, 72]. The weight of each cluster then is determined (step19). The weight of cluster 1 is 60, that of cluster 2 is also 60, andthat of cluster 3 is 72. Thus, all three clusters have weights that liewithin the range, include all nodes, and no cluster has any node incommon with another cluster (step 21). There are no unincludedsupernodes (step 25) or uncovered nodes (step 27), and all nodes havebeen assigned to a cluster (step 29). Since all clusters are within theweight range (step 33), the required domains are the clusters: cluster 1becomes domain 1, cluster 2 becomes domain 2, and cluster 3 becomesdomain 3 (step 37).

Example 2

In the example of FIGS. 6A-6C, a method for partitioning a differentgraph around anchor nodes is shown. There are three anchor nodes, 1, 6,and 11. These are shaded in FIG. 6A. In step 13, nine supernodes,labeled A through I in FIG. 6B, are identified, all of which form asingle cluster, since each supernode has at least two nodes in commonwith an adjacent supernode.

Since there are three anchor nodes, 1, 6 and 11, clusters arepartitioned around the anchor nodes (step 17). Supernode A is assignedto anchor node 1. This is because supernode A has no other nodesadjacent to an anchor node. Supernode E (or D, both meet therequirement) is assigned to anchor node 6, because supernode E (or D)has no other nodes adjacent to another anchor node. Supernode I isassigned to anchor node 11, because supernode I has only one other nodeadjacent to another anchor node (node 8 being adjacent to anchor node6).

No other supernodes may be assigned to anchor node 1 in a next round,since no other supernode includes node 1. Supernode D (or E) is assignedto anchor node 6, both having no nodes adjacent to another anchor nodeand which share an edge with a previously chosen supernode. Supernode His assigned to anchor node 11, since supernode H shares an edge with thepreviously chosen supernode I. All nodes are now marked and thefollowing clusters have been generated: Cluster 1, consisting of nodes1, 2 and 3; Cluster 2, consisting of nodes 4, 5, 6 and 7 and Cluster 3,consisting of nodes 8, 9, 10 and 11. The weight balancing phase is thencommenced (steps 19-37). In this example, it will be assumed that theclusters are fairly equally weighted, and thus they become the domains(step 37) as shown in FIG. 6C.

Example 3

This is a modification of Example 2. As shown in FIGS. 7A-7C, there are11 weighted nodes all having the same weight, 8 for example, and twoanchor nodes, nodes 5 and 9 (FIG. 7A). First, the domain weight range isdetermined (step 11). The total weight is 88 (8×11), and the averageweight is 44 (88÷2). Therefore, with a tolerance of ±8, the weight rangeis (44−8, 44+8)=[36, 52]. Nine supernodes are identified (step 13),labeled A through I in FIG. 7B, which form one cluster. Since there areno uncovered nodes (step 15), the cluster is partitioned into twoclusters (one for each of anchor nodes 5 and 9).

Anchor node 5 forms the cluster made up of supernodes B, C, D and E,having a weight of 48 (step 17, 19). Anchor node 9 forms the clustermade up of supernodes F, G and H, having a weight of 40 (steps 17, 19).The unincluded supernode list is {supernode A, supernode I}. Since nodes6 and 7 are contained in both clusters (step 31) and the weight of thecluster formed by anchor node 5 is greater than that formed by anchornode 9, both nodes are removed from the cluster formed by anchor node 5by deleting supernode D and E from the cluster (step 26). The weight ofthe cluster of anchor node 5 is now 32 and the weight of the cluster ofanchor node 9 is still 40 (step 19). Since two nodes in supernode A arein the cluster formed by anchor node 5, the supernode is assigned to thecluster and deleted from the list. Since two nodes of supernode I are inthe cluster formed by anchor node 9, the supernode is included in thecluster and deleted from the list (step 25). Every node has now beenincluded in exactly one cluster (step 29), and the cluster weights are40 and 48 (step 31) and within the range (step 33). Thus, the domainconfiguration shown in FIG. 7C is obtained (step 33).

Example 4

In Example 4, FIGS. 8A-8D, a method for partitioning a graph with elevennodes, all having the same weight, 8, for example, is shown. Nodes 3, 6and 9 are the anchor nodes, as shown in FIG. 8A. There are no weakedges. The total weight of the graph is 88, and the theoretical averageweight is (88/3)=29.33. Since the minimum weight is 8, the permissiblerange is (29.33−8, 29.33+8) or [21.33, 37.33] (step 11). To solve thisexample, the supernodes are first identified (step 13). These have beenlabeled A, B, . . . , G in the different triangular sections of thegraph, as shown in FIG. 8B. There is one uncovered node, node 7 (step15).

Having identified the supernode list and the uncovered node list,cluster formation is commenced (step 17). Starting with anchor node 3and choosing supernode A as the initial cluster, the cluster is expandedto include supernode B, then supernode C. (Supernode D includes anotheranchor node and so is not included.) The following set of nodescomprises the cluster {1, 2, 3, 4, 5}. Next, anchor node 6 isconsidered. Supernode E cannot be used for anchor node 6 since itincludes anchor node 9. Thus, for anchor node 6, supernode D is used asthe initial cluster. Next, supernode C is added. Supernode B cannot beincluded because its membership includes anchor node 3. Thus the clusteris the set of nodes {2, 4, 5, 6}. Finally, anchor node 9 is considered.Again, supernode E cannot be included since it includes anchor node 6.Thus, supernodes G and F form the cluster with the node set {8, 9, 10,11 }. There is no unincluded supernode, and the clusters are as shown inFIG. 8C.

The weights of clusters 1-3 are 40, 32 and 32, respectively (step 19).Now, clusters 1 and 2 have nodes 2, 4 and 5 in common (step 21).Starting with node 2, it is observed that it is in the same supernode asanchor node 3, so it is assigned to cluster 1 (step 23). Because cluster2 has a smaller weight than cluster 1, nodes 4 and 5 are assigned to it(step 23). Thus, the new cluster configuration is Cluster 1={1, 2, 3}and Cluster 2={4, 5, 6} both of which are now unique, and have weightsof 24 (step 19). There is an uncovered node, node 7, which has not beenassigned. It is adjacent to nodes in clusters 2 and 3. Since the weightof cluster 2 (24) is less than that of cluster 3 (32), node is assignedto cluster 2 (step 27). Thus, all nodes have been assigned (step 29),and the cluster memberships are unique. The weight of each cluster isthen computed (step 31). The weight of cluster 1 is 24, that of cluster2 is 32, and that of cluster 3 is also 32. Since all clusters haveweights that lie within the range (step 33), the clusters become thedomains (step 37), as shown in FIG. 8D.

Example 5

In the example of FIGS. 9A-9B, there are two anchor nodes, 1 and 3, andthe nodes are equally weighted. This example follows the same steps asexample 1. FIG. 9A shows a backbone network with four switchesrepresented by nodes 1, 2, 3 and 4, and seven other switches,represented by nodes 5 through 11 in the graph, each of which isconnected to two of the four backbone switches 1-4.

To commence the partitioning the weight range is determined (step 11).The total weight is 88 and the average weight is (88/2)=44. Therefore,the range is [36, 52]. It then is observed (step 13) that there areeleven supernodes, A-K, FIG. 9A, all of which form one cluster sinceeach supernode has two nodes in common with an adjacent supernode. Nonodes are uncovered (step 15). Since there are two anchor nodes, thecluster must be partitioned into two clusters (step 17). Since nodes 1and 3 are anchor nodes, they are required to be in different clusters.Thus, the cluster partitioning process is started with two supernodesassociated with nodes 1 and 3. With respect to anchor node 1, there isno supernode of which it is a member whose other nodes are not adjacentto anchor node 3. The same applies to anchor node 3. Thus, a supernodewill be assigned to an anchor node if it has at most one node adjacentto the other anchor node. Supernode A (or supernode B or supernode C,all of which meet the criterion), is assigned to anchor node 1 andsupernode H (or supernode I or supernode J or supernode K, since theyall meet the criterion) is assigned to anchor node 3.

Anchor node 1 will add supernodes B and C to supernode A. Similarly,anchor node 3 will add supernodes I, J and K to supernode H. The weightof the cluster of anchor node 1 is 40 and the weight of the cluster ofanchor node 3 is 48 (step 19). The clusters have no nodes in common(step 21) and no supernodes are unincluded (step 25). All nodes are nowcovered (steps 27, 29), and the clusters have weights within the range(steps 31, 33). The new clusters now become the required domains (step37), as shown in FIG. 9B.

Example 6

In the example of FIGS. 10A-10B, the nodes are equally weighted. Each ofseven nodes (5 through 11) is connected to two of four backbone nodes(1-4). The anchor nodes are nodes 1 and 3, shown shaded in FIG. 10A.

As described above in Example 5, since there are 11 nodes and 2 anchornodes, the weight range is [36, 52] (step 11). The supernodes arelabeled A-I (step 13). All nodes are covered (step 15) since every nodeis adjacent to at least two other nodes, thus the uncovered node list isempty. The cluster formed by anchor node 1 consists of supernodes A, B,C and D. The cluster formed by anchor node 3 consists of supernodes E,F, G, H and I (step 17). The weight of the cluster of anchor node 1 is48 and the weight of the cluster of anchor node 3 is 56 (step 19).

Since nodes 2 and 4 are in both clusters (step 21), and since thecluster formed by anchor node 3 has a larger weight than that formed byanchor node 1 (simply by having more nodes), supernode E is deleted fromthe cluster formed by anchor node 3 so that node 2 is solely within thecluster of anchor node 1 (step 22). However, node 4 is still common toboth clusters. For the special case of a quadded system, a rule isestablished that if an anchor node and some other node are in everysupernode in a cluster, that other node cannot be in another cluster.Thus, supernode A is deleted from the cluster formed by anchor node 1since node 4 is contained in every supernode in the cluster formed byanchor node 3 (step 23). Now the weight of the cluster of anchor node 1is 40 and the weight of the cluster of anchor node 3 is 48 (step 19). Nonodes are in common clusters (step 21), there are no unincludedsupernodes (step 25) or uncovered nodes (step 27), and all nodes areassigned to a cluster (step 25). The weights are within the range (steps31, 33) and the domains are formed (step 37). The domains are as shownin FIG. 10B.

Partitioning Degenerate Graphs

In some cases, the graphs which are to be partitioned may include moreuncovered nodes than covered nodes. In this case, the method describedabove may not provide the desired results. If, after step 15 of FIG. 3A,more than a threshold number of nodes of the graph are on the uncoverednode list, the graph is considered a “degenerate” graph. In a preferredembodiment of the invention, if the number of uncovered nodes is morethan 50% of the number of covered nodes, the graph is considered adegenerate graph. In a degenerate graph, there are more leaf nodes thannodes which are adjacent to at least two other nodes in a cluster. Inthis case, since supernodes and clusters cannot be formed and combinedas discussed above, the following alternative embodiment of the methodmay be carried out.

As explained with reference to FIG. 3B below, to partition degeneratecases, control groups are generated. Next, intra-group connectivity istested in order to define the domains. Specifically, if every pair ofnodes in the group can communicate without passing through a node thatis outside the group, the group constitutes a single domain; otherwise,it consists of two or more domains.

A simple way to partition the network into N_(A) control groups (whereN_(A) is the number of anchor nodes), illustrated in FIG. 3B.

Let “Anchor_List” denote the list of anchor nodes, and let“Nonanchor_List” denote the list of non-anchor nodes (step 18).

If W_(T) is the total weight of the nodes in the graph, the first memberof the Anchor_List is chosen as the starting member of the first controlgroup. Starting with the first member of the Nonanchor_List, as manynodes as possible are assigned to the first anchor node (step 20). Aseach non-anchor node is assigned, it is deleted from the Nonanchor_List(step 22). This is done until the total weight, including that of theselected anchor node, is W_(T)/N_(A), plus or minus a tolerance factor(step 24). When the weight of the control group is approximatelyW_(T)/N_(A), the anchor node is deleted from Anchor_List (step 26).

The above process is repeated with the next anchor node and the next setof nodes in the Nonanchor_List. The process is continued until all theanchor nodes have been chosen and the Anchor_List is empty (step 28).

Intra-group connectivity is tested (step 30) and the appropriate domainsare defined. In this case a distinction is made between a control groupand a domain. A control group is a set of nodes under the control of onecontrol agent or Virtual Name Server (VNS), which is a networkmanagement server which runs the switched network. A control groupbecomes a domain if a path exists between every pair of nodes in thegroup without passing through a node outside the group (step 32). Acontrol group can consist of several domains if the path between everypair of nodes in the group passes through a node that is not a member ofthe control group. If this is the case, domains are generated from eachnode in the control group (step 34).

EXAMPLES OF PARTITIONING DEGENERATE GRAPHS Example 7

In the example of FIGS. 11A-11B, a star configuration is shown, in whichall nodes are connected to a hub node. In FIG. 11A, there are 12 nodes,eleven of which are connected to node 1 in a star configuration. Nodes2, 6 and 9 are the anchor nodes. Thus, three domains must be formed. Inthis example, it is assumed that all nodes are equally weighted.

This example is a degenerate case because other than the hub switch (ornode), every other node is a leaf node. A leaf node is a node which isadjacent to only one other node. Thus, the desired feature that everynode in a domain be adjacent to at least two other nodes in the domainis non-existent.

Applying the method shown in FIG. 3B to the problem in FIG. 11A thefollowing is obtained:

Anchor_List=nodes {2,6,9} (step 18)

Nonanchor_List=nodes {1, 3, 4, 5, 7, 8, 10, 11, 12} (step 18)

Since, in this example, all the nodes have equal weight, the methodreduces to assigning the first three nodes in Nonanchor_List to thegroup controlled by anchor node 2, assigning the second set of threenodes to the group controlled by anchor node 6, and assigning the thirdset of three nodes to the group controlled by anchor node 9 (steps20-28). Thus, the control group configuration becomes the following:

Control Group 1, consisting of nodes {1, 2, 3, 4}, under the control ofanchor node 2.

Control Group 2, consisting of nodes {5, 6, 7, 8}, under the control ofanchor node 6.

Control Group 3, consisting of nodes {9, 10, 11, 12}, under the controlof anchor node 9.

Since all members of Control Group 1 can communicate with each other vianode 1 (step 30), the group constitutes a domain (step 32). However, allintra-group communication in the other control groups passes throughnode 1 which is in Control Group 1 (step 30). Thus, there are fourdomains in each of control group 2 (Domains 2-5) and control group 3(Domains 6-9) (step 34). The final configuration is as shown in FIG.11B. That is, there are three control groups and 9 domains in the graph.

Example 8

Another example of a degenerate case is shown in FIG. 12A, where twointerconnected anchor nodes form the hub of a butterfly (or double star)configuration. Anchor nodes 1 and 2 essentially constitute the backbonenetwork. This example occurs when the star configuration is required tohave a built-in redundancy. The redundant system can be on activestandby and, therefore, may be required to control a portion of thenetwork while the primary system is operational.

Since every node that is not an anchor node is adjacent to both anchornodes only, no supernodes may be formed and all of the nodes areuncovered (step 16). Two lists are defined as in Example 7, namely, theAnchor_List and the Nonanchor_List (step 18). The first set of nodes onthe Nonanchor_List are assigned to the first node on the Anchor_Listuntil their weights sum to approximately half the total weight (W_(T)/2)(two anchor nodes). In this case, nodes 3, 4, 5 and 6 are assigned toanchor node 1. The remaining nodes are then assigned to the second nodeon the Anchor_List. Nodes 7, 8, 9, 10 and 11 are assigned to anchor node2 (steps 20-28). Thus, two control groups are generated. Since the nodesin each group are all connected to the anchor node in each group (step30), each control group is a domain (step 32). Thus, the result shown inFIG. 12B is obtained. Domain 1 consists of nodes 1, 3, 4, 5 and 6, andDomain 2 consists of nodes 2, 7, 8, 9, 10 and 11.

The same general rule applies when k anchor nodes constitute thebackbone nodes of the graph (for any k>2) and when every non-anchor nodeis adjacent to every anchor node. The case of k=3 (i.e., the triple starconfiguration) is show in FIG. 13. The partition rule, as described withreference to FIG. 3B, is to assign the first set of non-anchor nodes tothe first anchor node until the total weight is approximately 1/k of thetotal weight, to assign the next set of non-anchor nodes to the secondanchor node until the weight constraint is met, and so on until all thenodes have been assigned.

Example 9

In Example 8, it was assumed that the number of anchor nodes requiredwas equal to the number of nodes in the backbone network. In practicethis may not be the case. In particular, the number of anchor nodes maybe more than the number of nodes in the backbone network. However,because of the special structure of the network, it is necessary todistinguish between network partitioning into domains and the assignmentof anchor nodes to the domains.

For example, in FIG. 14A there are three anchor nodes and two backbonenodes. Assume that the nodes are equally weighted. Thus, two anchornodes will support four nodes each and the third one will support threenodes. Now, since anchor nodes 1 and 2 are adjacent to all the othernodes in the network, each anchor node is assigned to a control domain.However, anchor node 9 is not adjacent to any non-anchor node and noneof the non-anchor nodes is adjacent to another non-anchor node. Thus,each of the nodes not assigned to a control domain under a backboneanchor node (1 or 2) constitutes a control domain. Applying the methoddescribed above for assigning VNS's, the two node lists are formed:

Anchor_List=nodes {1, 2, 9} (step 18)

Nonanchor_List=nodes {3, 4, 5, 6, 7, 8, 10, 1 1} (step 18)

With the average weight at approximately 29 ((8×11)÷3), the assignmentsare made as follows (steps 20-28):

Control Group 1, consisting of nodes {1,3,4,5}. This is Domain 1 underanchor node 1 (step 32).

Control Group 2, consisting of nodes {2,6,7,8). This is Domain 2 underanchor node 2 (step 32).

Control Group 3, consisting of nodes {9, 10, 11}. This is under anchornode 9 and consists of three domains:

Domain 3 (node 9), Domain 4 (node 10), and Domain 5 (node 11) (step 34).

The configuration becomes as shown in FIG. 14B.

Thus, if the topology is a star configuration, whether a simple starwith one hub or a complex star configuration with multiple hub nodes,the result is the same: First, the nodes are assigned to control groupsmanaged by the anchor nodes. If every node in each control group can bereached by every other node in the group without going through a nodeoutside the group, the control group constitutes a domain. For a givencontrol group, if a node in the group cannot be reached by other nodesin the group without passing through a node outside the group, that nodeconstitutes a domain.

Example 10

As another example, consider the three-star configuration in FIG. 15A.There are four anchor nodes 1, 2, 9, 12. Two of the nodes are backbonenodes (1 and 2) and the other two are non-backbone nodes (9 and 12).Assuming again that all nodes have equal weights, 8, for example, theneach anchor node must carry an approximate weight of 24 ((13×8)÷4).Following the method of listing the nodes, the following is obtained:

Anchor_List=nodes {1, 2, 9, 12} (step 18)

Nonanchor_List=nodes {3, 4, 5, 6, 7, 8, 10, 11, 13} (step 18)

Since one of the backbone nodes is not an anchor node (node 3), it isnot included in any control group that contains another backbone node.Thus, the control groups are as follows (steps 20-28):

Control Group 1, consisting of nodes {1, 4, 5}. This is Domain 1 underanchor node 1 (step 32).

Group 2, consisting of nodes {2, 6, 7}. This is Domain 2 under anchornode 2 (step 32).

Control Group 3, consisting of nodes {3, 8, 9}. This is Domain 3 underanchor node 9 (step 32).

Control Group 4, consisting of nodes {10, 11, 12, 13}. These are Domains4, 5, 6 and 7, respectively, under anchor node 12 (step 34).

The final configuration becomes the seven-domain, four control groupsystem shown in FIG. 15B.

Example 11

In the above examples, two extreme cases have been considered: wherethere is no backbone structure, and where a backbone structure exists.In some applications, there can be a mixture of these two cases.Consider the example shown in FIG. 16A. Shown in FIG. 16A is a treestructure embedded in the mesh configuration of FIG. 7A.

The partitioning, according to the above method, proceeds as follows.First, the three-node supernodes and the uncovered nodes are identified(steps 13, 15). For the uncovered nodes, their two-node supernodes areidentified. Since nodes 12, 13, 14, 15, 16 and 17 are uncovered, thenumber of uncovered nodes (6) is more than 50% of the number of coverednodes (11). Therefore, at step 16, the method of FIG. 3B is chosen.Nodes 5 and 9 are placed on the Anchor_List and nodes 1-4, 6-8 and 10-17are placed on the Nonanchor_List (step 18). Using the anchor nodes asthe starting points, control groups are formed. After all three-nodesupernodes have been included, the weight of each control group is foundand the two-node supernodes are assigned in a manner that balances theload among the control groups (steps 20-28). The domains in each controlgroup are then generated (steps 30-34).

Applying the above scheme to the example, the control group/domainconfiguration of FIG. 16B is obtained. As FIG. 16B illustrates, thereare two control groups (one under each anchor node) and five domains.There are four domains in Control Group 1 and only one domain in ControlGroup 2 since intra-control group communication in Control Group 2 doesnot require passing through a node that is outside that control group.Control group 1 consists of nodes 1, 2, 3, 4, 5, 12, 13 and 14. This isunder anchor node 9 and consists of four domains. Domain 1 consists ofnodes 1, 2, 3, 4, and 5, domain 2 consists of node 12, domain 3 consistsof node 13 and domain 4 consists of node 14. Control group 2 consists ofnodes 6, 7, 8, 9, 10, 11, 15, 16 and 17. This is Domain 5 under anchornode 9.

If, after the control groups and domains have been formed, one or morenodes goes out of service or is otherwise unable to operate properly,the VNS may rerun the partitioning method of the present invention. Oncethe network is re-partitioned into domains and control groups to reflectthe changed topography, and the server loads are balanced, and thenetwork is operated based on the new partitioning.

Partitioning Graphs Without Anchor Nodes

According to another embodiment of the present invention, a method ofpartitioning graphs without anchor nodes is provided. This method isuseful when the number and location of anchor nodes is not known or whena server which operates a domain becomes inoperable, and thereforeleaves a domain without a server or controller. It is also useful whenit becomes necessary to reassign the servers in a network, due to anoverload on a particular server or controller or to better distributeload across a network, for example. In this embodiment, the graph ispartitioned into a number of clusters and then the number of clusters ismanipulated to match a desired number of domains, which number willallow the most efficient operation of the network.

Although the method of this embodiment of the present invention isdescribed in more detail below, the method may generally be described asfollows with reference to FIG. 17. A preliminary phase of the methodfirst partitions the graph starting with the supernode identificationprocess outlined above. In step 310, strong and weak edges of the graphare identified, as described above. After the supernodes have beenidentified (step 312), they are then combined to form clusters (step314).

As described above, a node is considered “covered” if it is included inat least one supernode or one cluster. A cluster is configured such thateach node in the cluster is adjacent to at least two other nodes in thecluster.

If any supernode shares two or more nodes with another supernode, thesupernodes are combined into one cluster. If any supernode shares two ormore nodes with a cluster, the supernode is absorbed into the cluster.If two clusters have a node in common, one cluster is shrunken byremoving the shared node from the cluster. The number of clusters isdenoted by N_(c), and the number of desired domains is denoted by N_(D).

In step 316, N_(c) is compared to N_(D). If N_(c)=N_(D), the domainweight balancing stage (described below) is commenced (step 318), whichattempts to balance the weights across the domains. The weight of acluster is the sum of the weights of the nodes in the cluster.Controllers are then assigned to each domain (which corresponds to theidentified cluster) (step 320).

If the number of clusters is greater than the number of domains(N_(c)>N_(D)), clusters and supernodes are combined until the desirednumber of clusters is obtained (step 322). The remaining uncovered andcommon nodes are moved in order to balance the domains (step 318), andcontrollers are assigned to the domains (step 320).

In a case where the number of clusters is less than the number ofdomains (N_(c)>N_(D)), clusters are formed around uncovered nodes (step324) and larger clusters are split up to form smaller clusters (step326). In step 328, the number of clusters is reassessed, and comparedonce again to the number of desired domains in step 316. The processcontinues until the number of clusters equals the number of desireddomains and steps 318 and 320 are then executed.

Each step described above will now be discussed in greater detail.

Cluster Generation from Supernodes (step 314 of FIG. 17)

After the links have been identified (step 310) and the supernodes havebeen generated and placed in the supernode list as described above (step312), clusters are generated (step 314). A cluster is initiallygenerated by combining two supernodes that are adjacent (in the sensethat they have two nodes in common). The size of a cluster is increasedby progressively combining two clusters (or a cluster and a supernode)that are adjacent into larger clusters. When a supernode is absorbedinto a cluster, it is “marked” and will not be considered again in thecluster generation since the supernode cannot be in more than onecluster. Note, however, that the same node can be in more than onecluster if the node is in two or more supernodes that have no other nodein common. Thus the scheme can be formally defined as follows:

Let S denote a supernode list and let C denote a cluster list. Let S[i]denote the i^(th) member of S;

Let “app” denote an “append” operation, let “mrg” denote a “merge”operation, and let “cmp” denote a “comparison” operation; and

Let Len(S) denote the number of elements in S.

The cluster generation method can be stated as follows:

C = [ ] // initially the cluster list is empty fir (I=1; I<=Len(S); I++){ for S[i] unmarked { Mark S[i] for (j=I+1; j<=Len(S); j++) { CompareS[i] and S[j] if S[i] and S[j] match in two or more places {S[i]=S[i]mrg S[j] //merge S[i] and S[j] if S[j] is unmarked {Mark S[j]} if S[i]contains weak link { S[i]=S[i]−S[j] Unmark S[j] } } } } C=C app S[i] }// append S[i] to C

Thus, C contains clusters that are each composed of supernodes andclusters of supernodes where the supernodes have more than one node incommon with another supernode. The cluster does not include a weak edgethat may inadvertently be introduced via the supernode merging process.

Once the supernodes have been formed, the cluster formation complexitycan be computed as follows. Assume that there are m supernodes. To formclusters, those supernodes that have two nodes in common are considered.In the best case, all the supernodes form one cluster and so startingwith any supernode m−1 comparisons are made and a cluster is formed. Inthe worst case, all the supernodes are disjoint and m(m−1) comparisonsmust be made. Thus, the complexity is O(m²). The complexity of thedomain formation process depends on both the number of clusters formed,the number of domains required, and the number of uncovered nodes.

Domain Generation and Domain Weight Balancing (step 318 of FIG.17)—Overview

As stated earlier, the purpose of the preliminary phase is to provide aninitial starting point for partitioning the graph with no attention paidto the weight of each partition. The domain weight balancing phaseaddresses the need to ensure that all nodes are covered and that theweights are approximately the same in all domains (yet to be generated).If the total weight of the graph is W, the weight of each domain ideallyis L=[W/N_(D)].

As described above, a tolerance factor t may be defined for balancing ofweight among domains. If all nodes are covered, the graph is partitionedaround the clusters. If the weight of each cluster is L plus or minus t,the domains have been generated. If the weight of at least one clusteris larger than L plus t, boundary nodes are moved to reduce the weightuntil all clusters have weights within the range, making sure that suchadjustment does not include a weak edge in a cluster.

As described more fully below, if there are uncovered nodes, they aremoved into the clusters to balance the weights and avoid the inclusionof a weak edge in a cluster. In cases where the node can be included inmore than one cluster, it is preferable to include a node in a clusterwhere it is not adjacent to any member of the cluster via a weak edge.Alternatively, it is better to include a node in a cluster where it isadjacent to at least two other members of the cluster via non-weakedges. In general, unless it is absolutely necessary, an uncovered nodeshould not be included in a cluster where it is adjacent to only oneother node in the cluster. When all nodes are covered and all clustershave weights in the designated range, the clusters become domains.

In any event, when this step is performed, all the nodes may not becovered, but N_(c)=N_(D). Also, a covered node may belong to more thanone cluster. Since each node must belong to only one domain, membershipin each cluster may need to be modified not only to achieve the abovegoal but also to balance the weights of the different domains. Two casesare considered—when all the nodes are covered and when at least one nodeis uncovered.

Weight Balancing with All Nodes Covered (step 318 of FIG. 17 Where allNodes Covered)

There are two cases to consider: either all the clusters are disjoint orat least two clusters overlap (i.e., they have a node in common). If allthe clusters are disjoint, their weights are computed to ensure thatthey are within the predefined range, L±t.

The more challenging case is when the clusters are not all disjoint.Consider two clusters that have a node in common. First, the weight ofeach cluster is computed, by summing the weight of all nodes in eachcluster.

If one cluster was generated from an uncovered node and the othercluster was not generated from an uncovered node, the cluster generatedfrom an uncovered node retains all its nodes while all its neighboringclusters lose the nodes they share with that cluster. The clustermembership and weight of all its neighboring clusters are updated.

If both clusters were generated from uncovered nodes, the common node isassigned to the cluster with the smaller weight. Each cluster retainsall its other nodes and the membership of the other clusters is updatedto reflect the nodes they lost to the clusters generated from uncoverednodes.

If neither of the clusters was generated from an uncovered node, thenode is assigned to the cluster with the smaller weight and the weightsand the membership of the clusters are updated. This process is repeateduntil all clusters are disjoint.

Having obtained disjoint clusters with modified cluster membership, someof the clusters may contain nodes that are leaf nodes relative to theirclusters. A “leaf” node is a node that is adjacent to only one othernode in its environment. In this situation, the environment is thecluster.

Next, an attempt is made to balance two objectives. One objective is toensure that the weights in the clusters are balanced, and anotherobjective is to ensure that every node in a cluster is adjacent to atleast two other nodes, that is, there are no leaf nodes unlessabsolutely necessary.

The adjacency objective is addressed first, followed by weightbalancing. If a node is a leaf node in a cluster but is adjacent to atleast two other nodes in another cluster, the node is moved into thecluster where the other two nodes are located. Cluster membership andweights are updated. If no such cluster can be found, the node remainsin its present cluster.

The weights may then be balanced as follows. The weight of each clusteris determined and it is determined if the weight lies in the predefinedrange. If every weight lies in the range, the clusters become thedomains. If a cluster's weight is larger than the maximum allowed weight(W>L+t), a neighboring cluster having the smallest weight without a weaklink interconnecting them is found. A node which is adjacent to thesmaller cluster is moved to the smaller-weight cluster. Since the movednode may now be a leaf node, the cluster will examine its nodes to seeif it is still adjacent to the cluster into which it moved a node. If itis, and the new node (which is adjacent to a node in the other cluster)is also adjacent to the previously moved node, the second node is alsomoved into the other cluster; cluster membership and weights are thenupdated. If it is not, the new node remains a leaf node.

If its weight is less than the minimum allowed weight (W<L−t), theweights of all clusters to which the cluster is adjacent via non-weakedges are examined. If at least one such cluster exists, it will requestfrom the cluster with the largest weight the transfer of the nodethrough which the two clusters are adjacent. If the node transferred toit is now a leaf node, the cluster will attempt to acquire another nodefrom the cluster which is both adjacent to it and to the previouslymoved node. If such a node can be found and there is no weak edgeinvolved, it is also moved into the cluster; otherwise, the moved noderemains a leaf node.

This process of moving nodes continues until all clusters have weightsthat lie within the prescribed limits.

Weight Balancing with Nodes Uncovered (step 318 of FIG. 17. Where NotAll Nodes are Covered)

Consider a cluster that shares a node with one or more other clusters.If none of the clusters involved is adjacent to an uncovered node, thecommon node is assigned to the cluster with the smallest weight. If atleast one of the clusters is adjacent to an uncovered node, theuncovered node is moved into a cluster first before assigning the commonnode to one of the clusters. First, all weights of clusters that areadjacent to the uncovered node via a non-weak edge are found. The nodeis then moved into the cluster with the smallest weight, the weights andmembership of the clusters are updated, and after all uncovered nodeshave been assigned, the weights of all clusters that have a node incommon are determined and the common node is assigned to the clusterwith the smallest weight.

If an uncovered node is adjacent to two or more disjoint clusters vianon-weak edges, the node is assigned to the cluster with the smallestweight. If a node is adjacent to a set of clusters via non-weak edgesand one of these clusters is adjacent to the uncovered node via a leafnode, the uncovered node is assigned to the cluster with a leaf node ifthe weight of each cluster in the set is above the minimum weight.Otherwise, the node is assigned to the cluster with the smallest weight.

Cluster Generation from Uncovered Nodes (step 324 of FIG. 17)

When the number of clusters that have been generated is less than N_(D),and some nodes are uncovered, an attempt is made to define clustersaround these uncovered nodes (step 24). The following method may be usedto generate clusters from uncovered nodes. Let S_(N) denote the set ofnodes in the graph. Let S_(C) denote the list of nodes that appear atleast once in the cluster list. Finally, let S_(U) denote the list ofuncovered nodes; that is, S_(U)=S_(N)−S_(C).

For each node l in S_(U) and for each a_(ij) (=k) in A_(l) (adjacencylist for node l), the smallest circuit (i.e., a closed loop through thenodes) through l is found and appended to a cluster C. A variety ofmethods for identifying loops would be readily apparent to one of skillin the art. If two nodes x and y in A_(l) are both adjacent to a node t(which can be found from their adjacency lists), then a cluster {l, x,t, y} is formed from the circuit {l, x, t, y, l}, otherwise, for eachnode in A_(l), the next level of the adjacency search is started. Let xand y be nodes in A_(l). If a node m in A_(x) and a node n in A_(y) areboth adjacent to a node z, then a circuit {l, x, m, z, n, y, l} existsand the cluster {l, x, m, z, n, y} is included in cluster C. The methodis continued until N_(D)−N_(c) clusters have been generated using theuncovered nodes or all uncovered nodes are covered, whichever comesfirst.

Examples 13 and 14 (below) demonstrate cluster generation from uncoverednodes.

Cluster Partitioning (step 326 of FIG. 17)

When the number of clusters that have been generated is less than N_(D)(N_(c)<N_(D)) and all the nodes are covered, the larger clusters may bepartitioned into smaller clusters. Let N_(c) denote the number ofclusters in the current partitioning, C; that is, N_(c) is thecardinality of C. Thus, N_(D)−N_(c) additional clusters must begenerated. The method starts with the cluster with the largest number ofnodes and breaks it up into two clusters. If N_(c) is still less thanN_(D), it determines the next largest cluster and breaks it up into twoclusters, and so on until N_(D) =N_(c). The details of a clusterpartitioning method according to the present invention will now bedescribed. The clusters are arranged in decreasing order of cardinality(number of nodes within a cluster) and the cluster with the largestcardinality is chosen. Any two supernodes in the cluster that do nothave a node in common are taken and two clusters, each having one of thetwo supernodes are formed as the starting point. Any other supernode isthen added to one of the two partitioned clusters if that supernode doesnot share a node with any supernode in the other cluster. This processis continued until all the nodes in the original cluster are covered,and the cluster count is updated (N_(c)=N_(c)+1). If N_(c)=N_(D), thedomain generation stage (described below) is commenced; otherwise theprocess is repeated with the next cluster with the largest cardinality.

If the clusters are configured such that there are no supernodes in acluster that do not have a node in common, and therefore the clustercannot be partitioned into two clusters, the number of clusters remainsthe same, and any unassigned servers are used as back-ups to theassigned servers, or are reserved for future expansion. For example,consider the graph of FIG. 18. When the graph is partitioned accordingto the present invention, the graph contains two clusters (N_(c)=2).Cluster 1 includes nodes 1, 2, 3 and 4, and cluster 2 includes nodes 5,6 and 7. If N_(D)=3, an attempt is made to partition the clusters sothat N_(c)=3. However, in this case, neither cluster has supernodeshaving no nodes in common. Therefore, neither cluster may be partionedinto two separate clusters. In this case, the first server is assignedto cluster 1, the second server is assigned to cluster 2 and the thirdserver is used either as a back-up for the first and second servers oris reserved for future expansion of the graph. If more nodes are addedto the graph, the graph is repartioned and, as soon as the graph iscapable of being partitioned into three domains using the methoddescribed above, the third server is assigned to one of the threedomains.

Note that the method works well for the case where two nodes in twoseparate supernodes in the cluster are preferred to be in differentclusters (if they are connected by a weak edge, for example). In thiscase, two supernodes are chosen such that one supernode includes one ofthese two nodes and the other includes the other node, but the twosupernodes must not have a common node.

Example 15 (below) demonstrates cluster partitioning.

Cluster Combination (step 322 of FIG. 17)

When the number of clusters N_(c) is greater than N_(D) (N_(c)>N_(D)), atotal of N_(c)−N_(D) clusters must be merged with the other clusters. Toachieve this goal, all the clusters are first made to be disjoint.

Accordingly, every common node is assigned to the cluster with thelargest weight in the set of clusters in which it is located. If thenumber of nodes remaining in a cluster after the common node is removedis less than three, that cluster disappears from the cluster list (sincethe basic unit of cluster membership is the supernode and a supernodemust have at least three nodes). Then, the weight of each cluster isdetermined.

If the number of clusters is still greater than N_(D), the twolowest-weight clusters that are adjacent via at least two non-weakedges, if two such clusters exist, are combined into one cluster. Thecluster list, cluster weights and cluster membership are then updatedaccordingly.

If the number of clusters is still greater than N_(D), two lowest-weightclusters that are adjacent through one non-weak edge and an uncoverednode, if two such clusters exist, are combined into one cluster thatincludes the uncovered node.

If the number of clusters is still greater than N_(D), then, startingwith the smallest cluster by weight, any cluster that is adjacent to itvia two or more non-weak edges is combined into one cluster. Thisprocess is continued until the number of clusters is N_(D).

Example 16 (below) demonstrates cluster combination.

Examples of Partitioning Graphs Without Anchor Nodes

In the following sections, the method is detailed via examples 12-16. Inall the examples that follow it is assumed that there are threecontrollers; that is, N_(D)=3. The flowcharts which illustrate theexamples include corresponding references to the process illustrated inFIG. 17.

Example 12

FIGS. 19A-19C show a graph model of a communication network having nodes1-10 interconnected by edges, including two “bridge” edges connectingnodes 2 and 4 and nodes 5 and 7. In this example, it is assumed that allnodes have the same weight. FIG. 19D is a flowchart of a method toautomatically partition the graph of FIG. 19A. In step 120, fourtriangular supernodes are identified. These supernodes are outlined andlabeled supernodes A, B, C and D in FIG. 19B. Since supernodes C and Dhave nodes 7 and 10 in common, they are combined into one cluster (step122), thus giving three clusters. Since the total number of clusters anddomains is 3 (N_(D)=N_(c)) (step 125), the weight balancing phase isthen commenced (step 124). Clusters 1-3 are transformed into domains 1-3(step 126). In the weight balancing phase, it is first noted that allnodes in the graph are covered. Also, the weight of each potentialdomain is approximately the same. Thus the process is complete, anddomains 1-3 are as shown in FIG. 19C.

Having generated the domains, the domain controllers can then beassigned to them based on the appropriate assignment rules (step 128).Note that adding an edge between nodes 3 and 6 or between nodes 6 and 9would not change the above configuration (because the supernodes are thesame). On the other hand, if an edge were present between nodes 3 and 4(or between nodes 2 and 6), another triangular supernode is generatedconsisting of nodes 2, 3, and 4 (or nodes 2, 4, 6). Such a supernodewould share nodes 2 and 3 with supernode A and therefore it would bemerged with supernode A leaving node 4 in a cluster and a supernode.However, during the domain weight balancing phase, node 4 will be takenout of the cluster to balance the weights. Thus, the same configurationas above would be obtained.

Example 13

Referring now to the graph of FIGS. 20A-20F, which show nodes 1-11interconnected by edges, the method described above is implemented asshown in the flowchart of FIG. 20G. First, the supernodes areidentified, as described above (step 130). There are 7 of them, outlinedand labeled supernodes A through G in FIG. 20B. Since supernodes Athrough D each have two nodes in common, a cluster is formed from thesenodes (step 132). Similarly, since supernodes E through G each have twonodes in common, a second cluster is formed (step 134). (Both asdescribed above.) The new cluster configuration is shown in FIG. 20C.Now, there are two clusters (N_(C)=2) and three controllers (N_(D)=3).So, one more cluster must be generated (step 136). Since there is anuncovered node (node 7), an attempt to center the new cluster around itmust be made. Since a cluster is a set of nodes such that each member ofthe cluster is adjacent to at least two other members, a simple clustercomprising nodes 5, 6, 7 and 9 is identified (step 138). The resultingcluster configuration is shown in FIG. 20D.

There are now an equal number of clusters and controllers and the domainweight balancing phase is commenced (step 140). (This method isdescribed in greater detail above, with respect to the section titled“Weight Balancing with All Nodes Covered.”) Since Cluster 3 wasgenerated from an uncovered node, it retains all its nodes, as shown inFIG. 20E. Now, node 4 of Cluster 1 is a “leaf” node in cluster 1, as itis only connected to one other node in cluster 1. Since the weights ofall the clusters must fall within a predetermined range (±t), there aretwo choices: to not apply the adjacency rule (requiring any node in acluster to be adjacent to at least two other nodes in the cluster)meaning that node 4 remains in Cluster 1; or apply the adjacency ruleand move node 4 into Cluster 3 (step 142). This means that Cluster 1consists of nodes 1, 2 and 3, Cluster 3 consists of nodes 4, 5, 6, 7 and9, and Cluster 2 consists of nodes 8, 10 and 11. The latter case whichhas no leaf nodes is preferred, and the configuration shown in FIG. 20Fis obtained. Clusters 1-3 are then transformed into domains 1-3 (step144), and a controller is assigned to each domain (step 146).

Note that Domain 3 has five nodes while Domains 1 and 2 have three nodeseach. If the number of nodes is balanced by either assigning node 4 toDomain 1 or node 9 to Domain 2, domain configurations are obtained inwhich node 4 is adjacent to only one node in Domain 1 and node 7 isadjacent to only one node in Domain 3. In order to avoid these potentialleaf nodes, the domains remain as shown in FIG. 20F, as slightlyunbalanced domains are preferred over domains having leaf nodes.

Example 14

In the earlier examples, it was assumed that the nodes were equallyweighted. In the example of FIGS. 21A-21D, a graph model of acommunication network is illustrated, in which the nodes have differentweights. The weight of each node is indicated by the number next to eachnode. As shown in the flowchart of FIG. 21E, first, the domain weightrange is determined (step 150). In this example, the graph has a totalweight of 192. If a tolerance (t) of 8 is allowed, the weight in each ofthe three domains to be generated should be 192/3 (=64) plus or minus 8,or weights in the range [56-72]. Weak edges are then identified (step152). FIG. 21A shows three weak edges, edges (3, 5) (the edge from node3 to node 5), (4, 7), and (8, 11). As such, these are not expected to beintra-domain edges.

In generating the three required domains, first the supernodes areidentified (step 154). In this example, they are all triangularsupernodes, which are labeled A through F in FIG. 21B. Note that becauseedge (3, 5) is a weak edge, the triplets (3, 4, 5) and (3, 5, 6) are notidentified as supernodes.

Next, clusters are formed from the supernodes. Supernodes A and B sharetwo nodes (step 156), and so form cluster 1, FIG. 21C. Similarly,supernodes C and F, and F and E share two nodes and so form cluster 2(step 158). Supernode D forms cluster 3 (step 160). The number ofclusters is then compared to the desired number of domains (step 162).Since three clusters have been generated (N_(C)=3=N_(D)), thepreliminary phase is complete. Had the number of clusters been below orabove the desired number of domains, clusters would be generated orcombined, respectively, until N_(C)=N_(D) (step 164), as described inmore detail elsewhere herein.

The domain weight balancing phase is then commenced (step 166). First,it is observed that nodes 5 and 6 are not covered. Since they are notadjacent to any node in Cluster 2, they cannot be assigned to thatcluster. Also, since node 5 is adjacent to a node in Cluster 1 via aweak edge, it cannot be assigned to that cluster. Thus, it is assignedto Cluster 3 (step 168), where it remains currently as a leaf node. (Seediscussion above for a detailed description of a method foraccomplishing this.) Finally, node 6 can be assigned to either Cluster 1or Cluster 3. However, if it is assigned to Cluster 1, it will be a leafnode in that cluster. If it is assigned to Cluster 3, it is adjacent toboth leaf node 5 and node 9 in that cluster. So node 6 is assigned toCluster 3 (step 170), such that there are no leaf nodes in any cluster.

In step 172, the weight of each cluster is reevaluated. The weight ofCluster 1 is the sum of the weights of nodes 1-4 (60), the weight ofCluster 2 is the sum of nodes 7 and 10-14 (72), an weight of Cluster 3is the sum of nodes 5, 6, 8, 9 and 12 (60). Since these weights liewithin the desired range (56-72), clusters 1-3 become the domains 1-3(step 174) and controllers are assigned to the domains (step 176). Thefinal configuration is shown in FIG. 21D.

Example 15

FIGS. 22A-22D illustrates an example graph model of a communicationnetwork. This is a modification of Example 12, and it is assumed thatthe nodes are equally weighted. Operation of a method according to thepresent invention and processing the example of FIGS. 22A-22D is shownin the flowchart of FIG. 22E.

Supernodes A-E are identified (step 180) as shown in FIG. 22B. Supernodeidentification is described above. Note that the supernode consisting ofnodes 2, 3, 4 and 6 is a quad which encompasses supernodes of smallerdimensionality. Thus, the smaller supernodes contained in it are nolonger considered. Supernodes A, B and C are combined into one cluster(step 182), since supernodes A and B have two nodes in common, andsupernodes B and C have two nodes in common. Similarly, supernodes D andE form one cluster (step 184). Thus two clusters result (N_(c)=2), asshown in FIG. 22C. (This may be accomplished according to the methodsdescribed above.)

Since the number of clusters N_(C) (2) is less than N_(D) (3) (step186), the larger cluster, Cluster 1, is subdivided into two clusters(step 188). This is done by isolating supernodes in the cluster that donot have any node in common, namely supernode A and supernode C. If anysupernode is added to either of these, a node in the other supernodewill be encountered. Supernodes A and C then become clusters. Since allnodes in the cluster are covered, the required partition of the clusterhas been produced (N_(c)=N_(D)) (step 186) and the weight balancingphase is commenced (step 190). Domains 1-3 are then formed from clusters1-3 (step 192), and a controller is assigned to each domain (step 194).This results in the configuration of FIG. 22D.

Example 16

In the example of FIGS. 23A-23D, a case where N_(c)>N_(D) is shown. FIG.23A shows a graph having the weights of each node listed next to thenode. The graph includes weak links between nodes 5 and 8 and nodes 9and 12. The partitioning solution is shown in the flowchart of FIG. 23Eand begins with the identification of the supernodes (step 200). FIG.23B shows four clusters, 1-4, derived from the supernodes in step 202.Cluster 1 is formed as a result of combining the supernode consisting ofnodes 1, 2 and 3 and the supernode consisting of nodes 2, 3 and 5.Cluster 2 is formed as a result of combining the supernode consisting ofnodes 8, 11 and 12, the supernode consisting of nodes 11, 12 and 14, andthe supernode consisting of nodes 11, 14 and 15. Cluster 3 is formed asa result of converting the quad consisting of nodes 3, 4, 6 and 7 into acluster and Cluster 4 is formed from the supernode consisting of nodes9, 10 and 13. All the nodes in the graph are covered, and since fourclusters (N_(c)=4) have been generated and there are three controllers(N_(D)=3) (step 204), clusters must be combined (step 206) to produce atotal of three clusters. Since the total weight of the graph is 200, aweight in the range [59-75] (which is 200/3 plus or minus a tolerancefactor t of 8; is required in each of the domains to be generated.First, it is observed that node 3 is common to cluster 1 and cluster 3.The weight of cluster 1 is 60, and the weight of cluster 3 is 56, whichis below the desired range. Thus, node 3 is assigned to cluster 1. Theupdated configuration is shown in FIG. 23C. There are still fourclusters, 1-4, with weights 60, 72, 32, and 36, respectively. Sincecluster 3 and cluster 4 are the lowest-weight clusters and are adjacentvia two non-weak edges between nodes 6 and 9 and nodes 7 and 10, theyare combined into one cluster giving the configuration shown in FIG.23D.

Since the number of clusters is now three, the cluster combination iscomplete and the domain weight balancing phase is commenced (step 208).Now the clusters are disjoint and span all the nodes. The weights of theclusters are 60, 72 and 68 respectively. Since all clusters have weightsthat lie within the range, the clusters are transformed into therequired domains (step 210) and a controller is assigned to each domain(step 212).

Load Balancing

While the network is operating, the load on each server is monitored bythe VNS. If the load on a server exceeds a specified threshold, thedomain in which the server is operating can be slightly reconfigured.The VNS instructs the overloaded server to give up control of one of itsedge nodes to an adjacent server which is capable of taking on anothernode (e.g., has a lower load). This alleviates the load on theoverloaded server without the need for completely re-partitioning thenetwork. In the preferred embodiment of the invention, the loadthreshold is 50% of the server's capacity. When the VNS determines thata particular server is operating above 50% capacity, it initiates thenode passing method described above to alleviate the load on the server.In the case where adjacent nodes are overloaded such that passing edgenodes would not solve the overload condition, then the VNS re-partitionsthe network into load-balanced domains.

The method of the present invention may be implemented in a generalpurpose computer 300 as shown in FIG. 24. The computer may include acomputer processing unit (CPU) 302, memory 304, a processing bus 306 bywhich the CPU can access the memory 304, and access to a network 308.

The invention may be a computer apparatus which performs the methodpreviously described. Alternatively, the invention may be a memory 304,such as a floppy disk, compact disk, or hard drive, which contains acomputer program or data structure, for providing to a general computerinstructions and data for carrying out the method. In the preferredembodiment, the computer is part of a partitioning engine of a NetworkManagement Server, as described above.

Having thus described the invention, various modifications andimprovements will readily occur to those skilled in the art which areintended to be within the scope of the invention. While the inventionhas been described as a method for automatically partitioning a graphhaving a plurality of nodes interconnected by edges, where the nodesrepresent network devices and the edges represent links between thenetwork devices, the method may be applied to other media. For example,the nodes of the graph which is partitioned may represent components ofa VLSI chip and the edges of the graph may represent interconnectionsbetween the components, or the nodes of the graph may represent tasks tobe performed on a computer in a distributed computer system and theedges may represent data dependencies among the tasks. Accordingly, theforegoing description is by way of example only, and not intended to belimiting.

What is claimed is:
 1. A method for partitioning a communication networkinto partitions, the method comprising: modeling the network as a graphcomprising nodes which represent network devices and edges whichrepresent links between the devices; and automatically partitioning thegraph; and wherein the partitioning step includes a step of generatingpartitions such that links identified as weak links are not includedwithin any one partition.
 2. The method of claim 1, further comprisingassigning domain controllers to each of said partitions.
 3. A method forpartitioning a communication network into partitions, the methodcomprising: modeling the network as a graph comprising nodes whichrepresent network devices and edges which represent links between thedevices; automatically partitioning the graph; and assigning a weight toeach node in the graph; and wherein the partitioning step includes astep of balancing the combined weights of the nodes in each partition.4. The method of claim 3, wherein the generating step includes the stepof determining a range of acceptable weights for each partition.
 5. Themethod of claim 4, wherein the determining step includes the step ofdetermining a total of the weights of all nodes in the graph divided bya number of possible domains for the graph, plus and minus a smallestweight of all of the nodes.
 6. A method for partitioning a communicationnetwork, the method comprising: modeling the network as a graphcomprising nodes which represent network devices and edges whichrepresent links between the devices; automatically partitioning thegraph; wherein the partitioning step comprises: a step of identifyingsupernodes in the graph; and a step of combining supernodes which haveat least two nodes in common into a cluster.
 7. The method of claim 6,wherein each identified supernode comprises three fully connected nodes.8. The method of claim 7, wherein the network is partitioned intodomains and the partitioning step further comprises a step of generatingthe domains from the clusters.
 9. The method of claim 8, wherein thedomains are generated around anchor nodes such that each domain includesonly one anchor node.
 10. A domain partitioning engine comprising: meansfor receiving, a representation of a graph comprising nodes and edges;means for identifying a plurality of supernodes; and means, responsiveto the means for identifying, for automatically partitioning the graphinto a number of domains, at least one of which comprises one or more ofthe plurality of supernodes.
 11. The domain partitioning engine of claim10, further comprising means for assigning a weight to each node in thegraph; and wherein the means for partitioning includes means for tobalancing the combined weights of the nodes in each respectivepartition.
 12. The method of claim 11, wherein the means for generatingincludes means for determining a range of acceptable weights for eachpartition.
 13. The domain partitioning engine of claim 10, wherein themeans for identifying identifies supernodes consisting of three fullyconnected nodes.
 14. The domain partitioning engine of claim 10, furthercomprising: means for identifying a number of anchor nodes; means forcombining the supernodes into a number of clusters; means for generatingeach of the number of clusters around each of said number of anchornodes, such that each cluster includes only one anchor node; and meansfor generating the number of domains from the clusters.
 15. The domainpartitioning engine of claim 14, further comprising means for balancinga weight of the graph between the number of domains.
 16. The domainpartitioning engine of claim 10, wherein the nodes represent switches ina computer network and the edges represent links between the switches.17. The domain partitioning engine of claim 10, wherein the nodesrepresent components of a VLSI chip and the edges representinterconnections among the components.
 18. The domain partitioningengine of claim 10, wherein the nodes represent tasks to be performed ona computer in a distributed computing system and the edges representdata dependencies among the tasks.
 19. A method for using a computer toautomatically partition a graph comprising a plurality of nodesinterconnected by edges, the method comprising: (a) identifying aplurality of supernodes, each supernode comprising one or more pluralityof nodes; (b) forming clusters including one or more of the identifiedsupernodes; and (c) forming partitions from the clusters.
 20. The methodof claim 19, wherein the forming partitions step includes a step offorming partitions such that links identified as weak links are notincluded within any one partition.
 21. The method of claim 19, whereinthe step (b) comprises the steps of: combining supernodes having two ormore nodes in common into a cluster, wherein a cluster is a set of nodesin which each node in the set is linked to at least two other nodes inthe set; absorbing supernodes which share two or more nodes with acluster into the cluster; and separating clusters having a node incommon by removing the common node from one of the clusters.
 22. Themethod of claim 19, wherein each of the nodes includes a quantifiablecharacteristic, the method further comprising the steps of: (d)determining a sum of the quantifiable characteristic for each cluster;and (e) manipulating the clusters such that the sum of the quantifiablecharacteristic for each cluster falls within a range.
 23. The method ofclaim 22, wherein, if the sum of a particular domain falls above therange, step (e) comprises steps of: detecting an adjacent domain havinga smaller sum; and transferring a node from the particular domain to thedomain having a smaller sum.
 24. The method of claim 22, wherein, if thesum of a particular domain falls below the range, step (e) comprises thesteps of: detecting an adjacent domain having a greater sum; andtransferring a node from the domain having a greater sum to theparticular domain.
 25. The method of claim 19, wherein the nodesrepresent switches in a computer network and the edges represent linksbetween the switches.
 26. The method of claim 25, wherein each of thenodes includes a number of ports, the method further comprising thesteps of: (d) determining a sum of the number of ports in each cluster;and (e) manipulating the clusters such that the sum of the ports of eachcluster falls within a range.
 27. The method of claim 19, wherein thenodes represent tasks to be performed on a computer in a distributedcomputing system and the edges represent dependencies among the tasks.28. The method of claim 19, wherein the nodes represent components on aVLSI chip and the edges represent interconnections among the components.29. A method of automatically partitioning a graph into domains, thegraph having a plurality of nodes interconnected by a plurality ofedges, the method comprising: identifying a number of anchor nodes inthe graph; and combining the nodes into a number of control groups,which number is the same as the number of domains, such that eachcontrol group includes only one anchor node.